import java.util.Arrays;

//实现栈
public class MyStack {
    //public int[] elem;
    private int[] elem;
    private int usedSize;
    private static final int DEFAULT_SIZE=2;//默认大小

    //构造方法
    public MyStack(){
        elem=new int[DEFAULT_SIZE];
    }

    //存储数据-push
    public void push(int val){
        if(isFull()){//判断栈是不是满的
            //满了，扩容
            grow();
        }
        elem[usedSize]=val;
        usedSize++;
    }
    private boolean isFull(){
        return usedSize==elem.length;
    }
    private void grow(){
        elem= Arrays.copyOf(elem,elem.length*2);
    }

    //删除数据
    public int pop(){
        if(isEmpty()){//为空则不能删
            throw new StackEmptyException("栈为空异常！");
        }
        usedSize--;
        return elem[usedSize];//删除之后返回删除的栈顶元素
    }
    private boolean isEmpty(){
        return usedSize==0;
    }

    //获取栈顶元素，但不删除
    public int peek(){
        if(isEmpty()){
            throw new StackEmptyException("栈为空异常！");
        }
        return elem[usedSize-1];
    }

    //获取栈的元素个数
    public int size(){
        return usedSize;
    }
}
/*
在Java中，copyOf函数是Java标准库中用于数组复制的方法，位于java.util.Arrays类中。它有多个重载版本，以适应不同类型的数组复制需求。以下是一些常见的使用方式：

基本类型数组的复制
java

复制
import java.util.Arrays;

public class CopyOfExample {
    public static void main(String[] args) {
        int[] originalArray = {1, 2, 3, 4, 5};

        // 复制数组，新数组长度与原数组相同
        int[] copiedArray1 = Arrays.copyOf(originalArray, originalArray.length);

        // 复制数组，新数组长度大于原数组长度，剩余位置用默认值填充（对于int类型是0）
        int[] copiedArray2 = Arrays.copyOf(originalArray, 8);

        // 复制数组，新数组长度小于原数组长度，截断原数组
        int[] copiedArray3 = Arrays.copyOf(originalArray, 3);

        System.out.println("原数组: " + Arrays.toString(originalArray));
        System.out.println("长度相同的复制数组: " + Arrays.toString(copiedArray1));
        System.out.println("长度大于原数组的复制数组: " + Arrays.toString(copiedArray2));
        System.out.println("长度小于原数组的复制数组: " + Arrays.toString(copiedArray3));
    }
}
在上述代码中：

Arrays.copyOf(originalArray, originalArray.length) 复制原数组，新数组长度与原数组相同。
Arrays.copyOf(originalArray, 8) 创建一个长度为8的新数组，将原数组内容复制到新数组中，剩余位置用int类型的默认值（即0）填充。
Arrays.copyOf(originalArray, 3) 创建一个长度为3的新数组，只复制原数组的前3个元素。
对象数组的复制
java

复制
import java.util.Arrays;

class Person {
    private String name;

    public Person(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                '}';
    }
}

public class ObjectArrayCopyOfExample {
    public static void main(String[] args) {
        Person[] originalObjectArray = {new Person("Alice"), new Person("Bob")};

        // 复制对象数组
        Person[] copiedObjectArray = Arrays.copyOf(originalObjectArray, originalObjectArray.length);

        System.out.println("原对象数组: " + Arrays.toString(originalObjectArray));
        System.out.println("复制的对象数组: " + Arrays.toString(copiedObjectArray));
    }
}
在对象数组复制中，Arrays.copyOf复制的是对象引用，而不是对象本身（浅拷贝）。如果需要深拷贝对象数组，需要手动对每个对象进行深拷贝操作。

总结
Arrays.copyOf方法非常方便，可以快速复制数组并指定新数组的长度。它简化了数组复制的操作，提高了代码的可读性和可维护性。不同类型数组的复制方式基本类似，只是对于对象数组要注意浅拷贝和深拷贝的区别。


 Java 中的 copyOf 函数属于 java.util.Arrays 类，用于复制数组并返回一个新数组。它的主要用途是快速创建原数组的副本，并可以指定新数组的长度。如果新长度超过原数组长度，多余的位置会用默认值填充；如果小于原数组长度，则截取原数组的前部分元素。

函数签名
java

复制
public static <T> T[] copyOf(T[] original, int newLength)
public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType)
public static byte[] copyOf(byte[] original, int newLength)
// 其他基本类型（如int、double等）也有对应的重载方法
参数说明
original：要复制的原数组。
newLength：新数组的长度。
newType（可选）：新数组的类型（用于泛型数组）。
使用示例
示例1：复制整型数组
java

复制
import java.util.Arrays;

public class CopyOfExample {
    public static void main(String[] args) {
        int[] original = {1, 2, 3, 4, 5};

        // 复制原数组，新长度为3（截取前3个元素）
        int[] copy1 = Arrays.copyOf(original, 3);
        System.out.println(Arrays.toString(copy1)); // 输出 [1, 2, 3]

        // 新长度为7，超出部分用0填充
        int[] copy2 = Arrays.copyOf(original, 7);
        System.out.println(Arrays.toString(copy2)); // 输出 [1, 2, 3, 4, 5, 0, 0]
    }
}
示例2：复制对象数组
java

复制
import java.util.Arrays;

public class CopyOfExample2 {
    public static void main(String[] args) {
        String[] original = {"A", "B", "C"};

        // 复制为长度5的String数组，超出部分用null填充
        String[] copy = Arrays.copyOf(original, 5);
        System.out.println(Arrays.toString(copy)); // 输出 [A, B, C, null, null]
    }
}
关键特性
浅拷贝（Shallow Copy）
如果数组元素是对象（如 String、自定义类等），copyOf 仅复制对象的引用，不会创建对象的深拷贝。修改新数组中的对象会影响原数组。

java

复制
class User {
    String name;
    User(String name) { this.name = name; }
}

public class ShallowCopyExample {
    public static void main(String[] args) {
        User[] original = {new User("Alice"), new User("Bob")};
        User[] copy = Arrays.copyOf(original, 2);

        copy[0].name = "Charlie"; // 修改新数组的元素
        System.out.println(original[0].name); // 输出 "Charlie"（原数组也被修改）
    }
}
自动处理基本类型和对象数组
copyOf 可以处理所有基本类型数组（如 int[]、double[]）和对象数组（如 String[]）。

与 System.arraycopy() 的区别

Arrays.copyOf() 更简单，适合快速复制整个数组。
System.arraycopy() 更灵活，可以指定源数组和目标数组的位置及复制长度。
适用场景
调整数组大小：当需要扩展或缩短数组长度时。
快速复制数组：避免手动遍历数组赋值。
初始化默认值：当新数组长度大于原数组时，自动填充默认值（如 0、null）。
通过 Arrays.copyOf()，可以高效地操作数组，减少冗余代码。*/